home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / m68k / fbug68k.arc / GENERAL.C < prev    next >
C/C++ Source or Header  |  1989-09-29  |  13KB  |  616 lines
  1. #include"userdef.h"
  2.  
  3. /* ***************************************************** */
  4.  
  5. insertbr()
  6. {
  7. register int i;
  8. extern struct breakelem brtable[];
  9.  
  10.     for (i = 0; i < MAXBR; i++)
  11.     {
  12.         brtable[i].tempcount = brtable[i].count;
  13.         if (brtable[i].count >= 0)
  14.         {
  15.             brtable[i].inst1 = get16(brtable[i].address);
  16.             put16(brtable[i].address, BRTRAP);
  17.         }
  18.     }
  19. }
  20.  
  21. /* ***************************************************** */
  22.  
  23. whitesp(ch) /* see if ch is a whitespace character */
  24. char ch;
  25. {
  26.     if (ch == ' ' || ch == '\t' || ch == '\n' || ch == ENDSTR)
  27.         return(TRUE);
  28.     else
  29.         return(FALSE);
  30. }
  31.  
  32. /* ***************************************************** */
  33.  
  34. shiftarg(str,num) /* shift the string str, num characters to the left */
  35. char *str;
  36. int num;
  37. {
  38. register int i;
  39.  
  40.     for (i=0;str[i] != ENDSTR;i++)
  41.         str[i] = str[i+num];
  42. }
  43.  
  44. /* ***************************************************** */
  45.  
  46. striparg(str) /* strip characters from front of string until nonwhitespace */
  47. char *str;
  48. {
  49. register int j ;
  50.     for ( j = 0;!whitesp(str[j]); j++)
  51.         ;
  52.     while(whitesp(str[j]))
  53.          j++;
  54.     shiftarg(str, j);
  55. }
  56.  
  57. /* ***************************************************** */
  58. /*
  59. getnum routine converts an expression into number.
  60. It will continue to add and subtract until it reaches a special charachter or
  61. an error. If an error is found, a global flag, error, is set to TRUE. If no
  62. error is found, then the global flag error is set to FALSE. 
  63. The numbers in the expressiong string are converted according to DEFAULTSCALE,
  64. unless overridden by a delimiter in the string.
  65. */
  66. /* ***************************************************** */
  67.  
  68. getnum(str,err,iscale)
  69. char *str;
  70. char err[];
  71. int iscale;
  72. {
  73. extern int error;        /* global error flag */
  74. extern struct symbelem symb[];    /* symbol table */
  75. register int scale;        /* scale to convert numbers */
  76. register int final;        /* final sum of the expression */
  77. register int num;        /* temporary number holder */
  78. register int sign;        /* plus or minus */
  79. register int i,j;        /* loop counters */;
  80.  
  81.     scale = iscale;
  82.     num = 0;
  83.     sign = 1;
  84.     final = 0;
  85.     while (!whitesp(str[0]))
  86.     {
  87.         switch (str[0])
  88.         {
  89.             case '[':
  90.             case ']':
  91.             case '<':
  92.             case '>':
  93.             case '{':
  94.             case '}':
  95.             case '(':
  96.             case ')':
  97.             case COUNTDEL:
  98.             case ADDRDEL:
  99.                 final = final + sign * num;
  100.                 error = FALSE;
  101.                 return(final);
  102.             case BINDEL:
  103.                 scale = 2;
  104.                 num = 0;
  105.                 break;
  106.             case OCTDEL:
  107.                 scale = 8;
  108.                 num = 0;
  109.                 break;
  110.             case DECDEL:
  111.                 scale = 10;
  112.                 num = 0;
  113.                 break;
  114.             case HEXDEL:
  115.                 scale = 16;
  116.                 num = 0;
  117.                 break;
  118.             case PLUSDEL:
  119.                 final = final + sign * num;
  120.                 num = 0;
  121.                 sign = 1;
  122.                 scale = iscale;
  123.                 break;
  124.             case MINUSDEL:
  125.                 final = final + sign * num;
  126.                 num = 0;
  127.                 sign = -1;
  128.                 scale = iscale;
  129.                 break;
  130.             case SYMBOLDEL:
  131.                 for (i = 0; i < MAXSYMBOL;i++)
  132.                 {
  133.                     for (j=0; j < MAXSYMBLEN; j++)
  134.                         if (whitesp(symb[i].name[j]) || symb[i].name[j] != str[j])
  135.                             break;
  136.                     if (whitesp(symb[i].name[j]))
  137.                     {
  138.                         final = final + sign * symb[i].value;
  139.                         num = 0;
  140.                         sign = 1;
  141.                         scale = iscale;
  142.                         shiftarg(str,--j);
  143.                         break;
  144.                     }
  145.                     if (i == MAXSYMBOL)
  146.                     {
  147.                         error = TRUE;
  148.                         print(err);
  149.                         return(-1);
  150.                     }
  151.                 }
  152.                 break;
  153.             case '0':
  154.             case '1':
  155.             case '2':
  156.             case '3':
  157.             case '4':
  158.             case '5':
  159.             case '6':
  160.             case '7':
  161.             case '8':
  162.             case '9':
  163.                 num = num * scale + str[0] - '0';
  164.                 break;
  165.             case 'a':
  166.             case 'b':
  167.             case 'c':
  168.             case 'd':
  169.             case 'e':
  170.             case 'f':
  171.                 num = num * scale + str[0] - 'a' + 10;
  172.                 break;
  173.             case 'A':
  174.             case 'B':
  175.             case 'C':
  176.             case 'D':
  177.             case 'E':
  178.             case 'F':
  179.                 num = num * scale + str[0] - 'A' + 10;
  180.                 break;    
  181.             default:
  182.                 error = TRUE;
  183.                 print(err);
  184.                 return(-1);
  185.         }
  186.         shiftarg(str,1);
  187.     }
  188.     final = final + sign * num;
  189.     stripwhite(str);
  190.     error = FALSE;
  191.     return(final);
  192. }
  193.  
  194. /* ***************************************************** */
  195. /* 
  196. getsize returns the byte equivalent from the <size> option.
  197. It returns BYTE for -b, WORD for -w, HALF for -h, LONG for -l and DFSIZE if
  198. no option was expressed.
  199. */
  200. /* ***************************************************** */
  201.  
  202. getsize(str,err) /* get option size from command line */
  203. char *str;    /* string with possible option on it */
  204. char err[];    /* error message to print if error */
  205. {
  206.  
  207.     if (str[0] == OPTDEL)
  208.     {
  209.         switch (str[1])
  210.         {
  211.             case 'w':
  212.             case 'W':
  213.                 striparg(str);
  214.                 return(WORD);
  215.             case 'B':
  216.             case 'b':
  217.                 striparg(str);
  218.                 return(BYTE);
  219.             case 'L':
  220.             case 'l':
  221.                 striparg(str);
  222.                 return(LONG);
  223.             case 'H':
  224.             case 'h':
  225.                 striparg(str);
  226.                 return(HALF);
  227.             default:
  228.                 print(err);
  229.                 return(-1);
  230.         }
  231.     }
  232.     else
  233.         return(DFSIZE);
  234. }
  235.  
  236. /* ***************************************************** */
  237. /* 
  238. this returns the number of "size" large units in the memory area described
  239. by <range>. If <range> is two addresses, then the memory is divided into
  240. "size" large units. If <range> is a count, then the count is the number
  241. following the COUNTDEL. 
  242. */
  243. /* ***************************************************** */
  244.  
  245. getcount(str,size,strt,err)
  246. char *str;    /* string with <range> on it */
  247. int size;    /* 1,2 or 4; the number of bytes from <size> */
  248. int strt;    /* starting address */
  249. char err[];    /* error message to print if in error */
  250. {
  251. register int gansw;
  252.  
  253.     switch (str[0])
  254.     {
  255.         case COUNTDEL:
  256.             shiftarg(str,1);
  257.             gansw = getnum(str,err,COUNTSCALE);
  258.             return(gansw);
  259.         case ADDRDEL:
  260.             shiftarg(str,1);
  261.             gansw =(getnum(str,err,DEFAULTSCALE) - strt + 1) / size;
  262.             return(gansw);
  263.         default:    
  264.             print(err);
  265.             return(-1);
  266.     }
  267. }
  268.  
  269. /* ***************************************************** */
  270.  
  271. stripwhite(str)
  272. char *str;
  273. {
  274.     while (str[0] == ' ' || str[0] == '\t' || str[0] == '\n')
  275.         shiftarg(str,1);
  276. }
  277.  
  278. /* ***************************************************** */
  279.  
  280. check()
  281. {
  282. register char ch1;
  283.     ch1 = 0; /* get8(TERMINAL); */
  284.     if (ch1 == STOPCHAR)
  285.         return(TRUE);
  286.     else if (ch1 == HALTCHAR)
  287.         while (ch1 != CONTCHAR)
  288.             if (ch1 == STOPCHAR)
  289.                 return(TRUE);
  290.             else
  291.                 ch1 = get8(TERMINAL); 
  292.     return(FALSE);
  293. }
  294.  
  295. /* ***************************************************** */
  296.     
  297.  
  298. findport(str,err)
  299. char *str;
  300. char *err;
  301. {
  302. register int i,j;
  303. extern struct port_element p[];
  304.  
  305.     for(i=0;p[i].name != LASTCMD;i++)
  306.     {
  307.         for (j=0;p[i].name[j] != ENDCMD && p[i].name[j] == str[j];j++)
  308.                 ;
  309.         if (p[i].name[j] == ENDCMD && whitesp(str[j]))
  310.             return(i);
  311.     }
  312.     print(err);
  313.     return(-1);
  314. }
  315.  
  316. /* ***************************************************** */
  317.  
  318. #if(DEVICE==68040 || COPROCESSOR==TRUE)
  319.  
  320. printfpu()
  321. {
  322. extern struct regelem mpu[];
  323. register int i,j;
  324.  
  325.     for (i = 0;mpu[i].name[0] != 'F' && mpu[i].name[1] != 'P';i++)
  326.         ;
  327.  
  328.     print("\n");
  329.     for (;mpu[i].name != LASTCMD;i++)
  330.     {
  331.         if (mpu[i].name[0] == BREAK)
  332.             print("\n");
  333.         else if (mpu[i].name[2] >= '0' && mpu[i].name[2] <= '7')
  334.         {
  335.             if (mpu[i].name[2] == '0')
  336.                 print("\n");
  337.             print(mpu[i].name);
  338.             print("=%c%8x%8x%8x   ",HEXDEL,mpu[i].value,mpu[i+1].value,mpu[i+2].value);
  339.             printFPx(i);
  340.             i++;
  341.             i++;
  342.             j = 0;
  343.             print("\n");
  344.         }
  345.         else
  346.         {
  347.             print(mpu[i].name);
  348.             print("=%c%8x   ",HEXDEL,mpu[i].value);
  349.             j++;
  350.         }
  351.         check();
  352.     }
  353.     print("\n");
  354. }
  355.  
  356. /* ************************************************************************* */
  357. /* ROUTINE: printFPx                                 */
  358. /* ************************************************************************* */
  359.  
  360. printFPx(mpu_entry)
  361. int mpu_entry;
  362. {
  363.  
  364. extern struct regelem mpu[];
  365. int f0_fp,f1_fp,f2_fp;
  366.  
  367.     f0_fp=mpu[mpu_entry].value;
  368.     f1_fp=mpu[mpu_entry+1].value;
  369.     f2_fp=mpu[mpu_entry+2].value;
  370.     print("     ");
  371.     if(bitnum(31,31,f0_fp))
  372.         print("-");
  373.     print("%d_%8x%8x_E%d",bitnum(31,31,f1_fp),(bitnum(30,0,f1_fp)<<1),bitnum(31,0,f2_fp),bitnum(30,16,f0_fp)-16383);
  374. }
  375.  
  376. #endif
  377.  
  378. /* ***************************************************** */
  379.  
  380. printreg(reg)
  381. struct regelem reg[];
  382. {
  383. register int i,j;
  384.  
  385.     j = 0;
  386.     for (i = 0;reg[i].name != LASTCMD && reg[i].name[0] != 'F';i++)
  387.     {
  388.         if (reg[i].name[0] == BREAK)
  389.         {
  390.             j = 0;
  391.             print("\n");
  392.         }
  393. #if(DEVICE<68020)/* ie. 68010 */
  394.         else if(i==4 || i==7 || i==8)
  395.             ;
  396. #endif
  397. #if(DEVICE<68010)/* ie. 68000,68008 */
  398.         else if(i==6 || i==9 || i==10)
  399.             ;
  400. #endif
  401. #if(DEVICE>=68030)
  402.         else if(reg[i].name[1] == 'R' && reg[i].name[2]!=' ')
  403.         {
  404.             print(reg[i].name);
  405.             print("=%c%8x%8x    ",HEXDEL,reg[i].value,reg[i+1].value);
  406.             i++;
  407.             j++;
  408.         }
  409.         else if((reg[i].name[0] == 'S' && reg[i].name[1]=='R') ||
  410.             (reg[i].name[1] == 'S' && reg[i].name[2]=='R')) 
  411.         {
  412.             print(reg[i].name);
  413.             print("=%c%4x   ",HEXDEL,reg[i].value);
  414.             j++;
  415.         }
  416. #endif
  417.         else
  418.         {
  419.             print(reg[i].name);
  420.             print("=%c%8x   ",HEXDEL,reg[i].value);
  421.             j++;
  422.         }
  423.         if (j == REGPERLINE)
  424.         {
  425.             j = 0;
  426.             print("\n");
  427.         }
  428.         else if (i != 0 && (i % REGPERSCREEN) == 0)
  429.         {
  430.             j = 0;
  431.             print("\n");
  432.         }
  433.         check();
  434.     }
  435.     print("\n");
  436. }
  437.  
  438. /* **************************************************** */
  439.  
  440. findreg(reg,strng,query,argv)
  441. char *strng;
  442. struct regelem reg[];
  443. int query;
  444. char *argv;
  445. {
  446. register int i,j;
  447. extern int error;
  448. #if(DEVICE>=68030 || COPROCESSOR==TRUE)
  449. int k,l;
  450. char upper[9];
  451. #endif
  452.  
  453.     for (i = 0;reg[i].name != LASTCMD;i++)
  454.     {
  455.         for (j = 0;reg[i].name[j] != ENDCMD && ((CONVCAP && reg[i].name[j] == strng[j] - 0x20) || reg[i].name[j] == strng[j]);j++)
  456.             ;
  457.         if (reg[i].name[j] == ENDCMD && (strng[j]==ENDSTR && !query) || (query && strng[j]== ENDCMD))
  458.             break;
  459.     }
  460.     if (reg[i].name == LASTCMD)
  461.     {
  462.         print("ERROR 17:Invalid Register\n");
  463.         return(0);
  464.     }
  465.     striparg(strng);
  466. #if(DEVICE<68020)/* ie. 68010 */
  467.         if(i==4 || i==7 || i==8)
  468.             {
  469.                 print("ERROR 12:Unimplemented Register\n");
  470.                 return(0);
  471.             }
  472. #endif
  473. #if(DEVICE<68010)/* ie. 68000,68008 */
  474.         if(i==6 || i==9 || i==10)
  475.             {
  476.                 print("ERROR 12:Unimplemented Register\n");
  477.                 return(0);
  478.             }
  479. #endif
  480.     if(!query)
  481.         print(reg[i].name);
  482. #if(DEVICE>=68030)
  483.     if(reg[i].name[1] == 'R' && reg[i].name[2] != ' ')
  484.         /* set up to fill the register up with
  485.            the existing routines */
  486.     {
  487.         if(!query)
  488.             print("=%c%8x%8x New value? ",HEXDEL,reg[i].value,reg[i+1].value);
  489.         if(query)
  490.             strng = argv;
  491.         else if(getline(strng) != 1)
  492.         {
  493.             print(ERR01);
  494.             return;
  495.         }
  496.         stripwhite(strng);
  497.         if(strng[0]=='&' || strng[0]=='@')
  498.             {
  499.             print("\nHex Base must be used\n");
  500.             return;
  501.             }
  502.         else if(strng[0]==HEXDEL)
  503.             shiftarg(strng,1);
  504.         for(k=0;strng[k]!=ENDSTR;k++)
  505.             ;
  506.         if(k>16)
  507.             {
  508.             print(ERR03);
  509.             return;
  510.             }
  511.         else if(k>8)
  512.             {
  513.             for(l=0;l<=k-9;l++)
  514.                 upper[l]=strng[l];
  515.             upper[l]=ENDSTR;
  516.             reg[i].value = getnum(upper,ERR03,DEFAULTSCALE);
  517.             if (error)
  518.                 return;
  519.             shiftarg(strng,k-8);
  520.             }
  521.         else
  522.             reg[i].value = 0;
  523.         i++;
  524.         reg[i].value = getnum(strng,ERR03,DEFAULTSCALE);
  525.         return;
  526.     }
  527.     if((reg[i].name[0] == 'S' && reg[i].name[1] == 'R') ||
  528.         (reg[i].name[1] == 'S' && reg[i].name[2] == 'R'))
  529.     {
  530.         if(!query)
  531.             print("=%c%4x New value? ",HEXDEL,reg[i].value);
  532.         if(query)
  533.             strng = argv;
  534.         else if(getline(strng) != 1)
  535.         {
  536.             print(ERR01);
  537.             return(0);
  538.         }
  539.         reg[i].value = getnum(strng,ERR03,DEFAULTSCALE);
  540.         return;
  541.     }
  542. #endif
  543. #if(DEVICE==68040 || COPROCESSOR==TRUE)
  544.     if(reg[i].name[1] == 'P' 
  545.         && reg[i].name[2] >= '0' 
  546.         && reg[i].name[2] <= '7')
  547.     {
  548.         if(!query)
  549.             print("=%c%8x%8x%8x New value? ",HEXDEL,reg[i].value,reg[i+1].value,reg[i+2].value);
  550.         if(query)
  551.             strng = argv;
  552.         else if(getline(strng) != 1)
  553.         {
  554.             print(ERR01);
  555.             return;
  556.         }
  557.         stripwhite(strng);
  558.         if(strng[0]=='&' || strng[0]=='@')
  559.             {
  560.             print("\nHex Base must be used\n");
  561.             return;
  562.             }
  563.         else if(strng[0]==HEXDEL)
  564.             shiftarg(strng,1);
  565.         for(k=0;strng[k]!=ENDSTR;k++)
  566.             ;
  567.         if(k>24)
  568.             {
  569.             print(ERR03);
  570.             return;
  571.             }
  572.         if(k>16)
  573.             {
  574.             for(l=0;l<=k-17;l++)
  575.                 upper[l]=strng[l];
  576.             upper[l]=ENDSTR;
  577.             reg[i++].value = getnum(upper,ERR03,DEFAULTSCALE);
  578.             if (error)
  579.                 return;
  580.             shiftarg(strng,k-16);
  581.             k = k-8;
  582.             }
  583.         else
  584.             reg[i++].value = 0;
  585.         if(k>8)
  586.             {
  587.             for(l=0;l<=k-9;l++)
  588.                 upper[l]=strng[l];
  589.             upper[l]=ENDSTR;
  590.             reg[i++].value = getnum(upper,ERR03,DEFAULTSCALE);
  591.             if (error)
  592.                 return;
  593.             shiftarg(strng,k-8);
  594.             k = k-8;
  595.             }
  596.         else
  597.             reg[i++].value = 0;
  598.         reg[i].value = getnum(strng,ERR03,DEFAULTSCALE);
  599.         return;
  600.     }
  601. #endif
  602.     if(!query)
  603.         print("=%c%8x New value? ",HEXDEL,reg[i].value);
  604.     if(query)
  605.         strng = argv;
  606.     else if(getline(strng) != 1)
  607.     {
  608.         print(ERR01);
  609.         return(0);
  610.     }
  611.     reg[i].value = getnum(strng,ERR03,DEFAULTSCALE);
  612. }
  613.  
  614. /* ****************************************************** */
  615.  
  616.